Grid method multiplication

 ( Mathematics Education ) 

The grid method (also known as the box method or matrix method) of multiplication is an introductory approach to multi-digit multiplication calculations that involve numbers larger than ten.

Compared to traditional long multiplication, the grid method differs in clearly breaking the multiplication and addition into two steps, and in being less dependent on place value.

Whilst less efficient than the traditional method, grid multiplication is considered to be more reliable, in that children are less likely to make mistakes. Most pupils will go on to learn the traditional method, once they are comfortable with the grid method; but knowledge of the grid method remains a useful "fall back", in the event of confusion. It is also argued that since anyone doing a lot of multiplication would nowadays use a pocket calculator, efficiency for its own sake is less important; equally, since this means that most children will use the multiplication algorithm less often, it is useful for them to become familiar with a more explicit (and hence more memorable) method.

Use of the grid method has been standard in mathematics education in primary schools in England and Wales since the introduction of a National Numeracy Strategy with its "numeracy hour" in the 1990s. It can also be found included in various curricula elsewhere. Essentially the same calculation approach, but not with the explicit grid arrangement, is also known as the partial products algorithm or partial products method.

---

Calculations

---

Introductory motivation The grid method can be introduced by thinking about how to add up the number of points in a regular array, for example the number of squares of chocolate in a chocolate bar. As the size of the calculation becomes larger, it becomes easier to start counting in tens; and to represent the calculation as a box which can be sub-divided, rather than drawing a multitude of dots. Long multiplication − The Box method Long multiplication and division

At the simplest level, pupils might be asked to apply the method to a calculation like 3 × 17. Breaking up ("partitioning") the 17 as (10 + 7), this unfamiliar multiplication can be worked out as the sum of two simple multiplications:

>

! scope="col" width="40pt" × ! scope="col" width="40pt"	10 ! scope="col" width="40pt"	7

so 3 × 17 = 30 + 21 = 51.

This is the "grid" or "boxes" structure which gives the multiplication method its name.

Faced with a slightly larger multiplication, such as 34 × 13, pupils may initially be encouraged to also break this into tens. So, expanding 34 as 10 + 10 + 10 + 4 and 13 as 10 + 3, the product 34 × 13 might be represented:

>

! scope="col" width="40pt" × ! scope="col" width="40pt"	10 ! scope="col" width="40pt"	10 ! scope="col" width="40pt"	10 ! scope="col" width="40pt"	4

Totalling the contents of each row, it is apparent that the final result of the calculation is (100 + 100 + 100 + 40) + (30 + 30 + 30 + 12) = 340 + 102 = 442.

---

Standard blocks

Once pupils have become comfortable with the idea of splitting the whole product into contributions from separate boxes, it is a natural step to group the tens together, so that the calculation 34 × 13 becomes

>

! scope="col" width="40pt" × ! scope="col" width="120pt"	30 ! scope="col" width="40pt"	4

giving the addition

:>

300 40 90 + 12 ———— 442

so 34 × 13 = 442.

This is the most usual form for a grid calculation. In countries such as the UK where teaching of the grid method is usual, pupils may spend a considerable period of time regularly setting out calculations like the above, until the method is entirely comfortable and familiar.

---

Larger numbers

The grid method extends straightforwardly to calculations involving larger numbers.

For example, to calculate 345 × 28, the student could construct the grid with six easy multiplications

>

! scope="col" width="40pt" × ! scope="col" width="40pt"	300 ! scope="col" width="40pt"	40 ! scope="col" width="40pt"	5

to find the answer 6900 + 2760 = 9660.

However, by this stage (at least in standard current UK teaching practice) pupils may be starting to be encouraged to set out such a calculation using the traditional long multiplication form without having to draw up a grid.

Traditional long multiplication can be related to a grid multiplication in which only one of the numbers is broken into tens and units parts to be multiplied separately:

>

! scope="col" width="40pt" × ! scope="col" width="120pt"	345

The traditional method is ultimately faster and much more compact; but it requires two significantly more difficult multiplications which pupils may at first struggle with . Compared to the grid method, traditional long multiplication may also be more abstract and less manifestly clear , so some pupils find it harder to remember what is to be done at each stage and why . Pupils may therefore be encouraged for quite a period to use the simpler grid method alongside the more efficient traditional long multiplication method, as a check and a fall-back.

---

Other applications

---

Fractions

While not normally taught as a standard method for multiplying fractions, the grid method can readily be applied to simple cases where it is easier to find a product by breaking it down.

For example, the calculation 2 × 1 can be set out using the grid method

>

! scope="col" width="40pt" × ! scope="col" width="40pt"	2 ! scope="col" width="40pt"

to find that the resulting product is 2 + + 1 + = 3

---

Algebra

The grid method can also be used to illustrate the multiplying out of a product of binomials, such as ( a + 3)( b + 2), a standard topic in elementary algebra (although one not usually met until secondary school):

>

! scope="col" width="40pt" × ! scope="col" width="40pt"	a ! scope="col" width="40pt"	3

Thus ( a + 3)( b + 2) = ab + 3 b + 2 a + 6.

---

Computing

32-bit CPUs usually lack an instruction to multiply two 64-bit integers. However, most of them do allow for taking the full 64-bit result from a multiplication between two 32-bit integers, a "long multiply". This usually involves generates outputs in two separate registers (like mul r/m32 introduced with the 80386 and umull added in the ARMv4t instruction set).

On platforms that support these instructions, a slightly modified version of the grid method is used. Instead of using multiples of 10, we use multiples of 2³², i.e. 0x100000000. A 64-bit integer can be divided into two such numbers by splitting it down the middle.

In addition, the multiplication of two 64-bit integers technically produces a 128-bit result. If only the lower 64-bit are needed (such as here), one 32-bit multiplication can be saved. This is because the grid method is based on the fact that $(Nb\; +\; a)(Nd+c)\; =\; ac\; +\; N(bc+ad)\; +\; N^2(bd)$. Because N = 2³², N² = 2⁶⁴, so any result in $bd$ would be shifted out of the 64-bit range. This also means that only one 32-bit "long multiply" is needed, as the higher 32 bits of bc and ad too would be shifted out of range.

This would be the routine in C:

1. include

uint64_t multiply(uint64_t ab, uint64_t cd) {

   /* These shifts and masks are usually implicit, as 64-bit integers
    * are often passed as 2 32-bit registers. */
   uint32_t b = ab >> 32, a = ab & 0xFFFFFFFF;
   uint32_t d = cd >> 32, c = cd & 0xFFFFFFFF;
     

   /* multiply with overflow */
   uint64_t ac = (uint64_t)a * (uint64_t)c;
   uint32_t high = ac >> 32; /* overflow */
   uint32_t low = ac & 0xFFFFFFFF;
     

   /* 32-bit multiply and add to high bits */
   high += (a * d); /* add ad */
   high += (b * c); /* add bc */
   /* multiply by 0x100000000 (via left shift) and add to the low bits with a binary or. */
   return ((uint64_t)high << 32) | low;
     

} This would be the routine in ARM assembly: multiply:

       ; a = r0
       ; b = r1
       ; c = r2
       ; d = r3
       push    {r4, lr}        ; backup r4 and lr to the stack
       umull   r12, lr, r2, r0 ; multiply r2 and r0, store the result in r12 and the overflow in lr
       mla     r4, r2, r1, lr  ; multiply r2 and r1, add lr, and store in r4
       mla     r1, r3, r0, r4  ; multiply r3 and r0, add r4, and store in r1
                               ; The value is shifted left implicitly because the
                               ; high bits of a 64-bit integer are returned in r1.
       mov     r0, r12         ; Set the low bits of the return value to r12 (ac)
       pop     {r4, lr}        ; restore r4 and lr from the stack
       bx      lr              ; return the low and high bits in r0 and r1 respectively
     

---

Mathematics

Mathematically, the ability to break up a multiplication in this way is known as the distributive law, which can be expressed in algebra as the property that a( b+ c) = ab + ac. The grid method uses the distributive property twice to expand the product, once for the horizontal factor, and once for the vertical factor.

Historically the grid calculation (tweaked slightly) was the basis of a method called lattice multiplication, which was the standard method of multiple-digit multiplication developed in medieval Arabic and Hindu mathematics. Lattice multiplication was introduced into Europe by Fibonacci at the start of the thirteenth century along with Arabic numerals themselves; although, like the numerals also, the ways he suggested to calculate with them were initially slow to catch on. Napier's bones were a calculating help introduced by the Scot John Napier in 1617 to assist lattice-method calculations.

---

See also

• Multiplication algorithm
• Multiplication table

• Rob Eastaway and Mike Askew, Maths for Mums and Dads, Square Peg, 2010. . pp. 140–153.

---

External links

• Long multiplication − The Box method, Maths online.
• Long multiplication and division, BBC GCSE Bitesize

Categories: Mathematics Education, Elementary Arithmetic, Multiplication, Primary Education

Post Comment